Managing complex data models and optimizing performance in Knockout.js can be achieved through a combination of advanced techniques and best practices. Here are some strategies to handle complex data models and optimize performance in your Knockout.js applications:

1. Using Custom Bindings
Custom bindings allow you to encapsulate complex logic and reuse it across your application. They can be particularly useful for handling complex UI interactions.

ko.bindingHandlers.enterKey = {
   init: function(element, valueAccessor, allBindings, viewModel) {
       var callback = valueAccessor();
       $(element).keypress(function(event) {
           if (event.which === 13) {
               callback.call(viewModel);
               return false;
           }
           return true;
       });
   }
};

2. Managing Large Data Sets
When dealing with large data sets, consider using techniques like paging, virtual scrolling, or lazy loading to improve performance.

Paging Example:

function ViewModel() {
   var self = this;
   self.items = ko.observableArray([...]); // large data set
   self.pageSize = ko.observable(10);
   self.currentPage = ko.observable(1);
   self.pagedItems = ko.computed(function() {
       var startIndex = (self.currentPage() - 1) * self.pageSize();
       return self.items.slice(startIndex, startIndex + self.pageSize());
   });
   self.totalPages = ko.computed(function() {
       return Math.ceil(self.items().length / self.pageSize());
   });
   self.nextPage = function() {
       if (self.currentPage() < self.totalPages()) {
           self.currentPage(self.currentPage() + 1);
       }
   };
   self.prevPage = function() {
       if (self.currentPage() > 1) {
           self.currentPage(self.currentPage() - 1);
       }
   };
}
ko.applyBindings(new ViewModel());

3. Using ko.mapping for Complex Models
The knockout.mapping plugin helps manage complex models by automatically mapping JavaScript objects to Knockout observables.

// Include knockout.mapping.js
var data = {
   id: 1,
   name: "John",
   address: {
       street: "123 Main St",
       city: "Somewhere"
   }
};
var viewModel = ko.mapping.fromJS(data);
ko.applyBindings(viewModel);

4. Efficient Computed Observables
Optimize computed observables by using the deferEvaluation option to delay evaluation until the value is accessed.

var firstName = ko.observable('John');
var lastName = ko.observable('Doe');
var fullName = ko.computed(function() {
   return firstName() + ' ' + lastName();
}, null, { deferEvaluation: true });

5. Using Subscriptions Wisely
Be cautious with subscriptions, especially when working with complex data models. Use throttle or rateLimit to control the frequency of updates.

var searchQuery = ko.observable().extend({ rateLimit: { method: "notifyWhenChangesStop", timeout: 400 } });
searchQuery.subscribe(function(newValue) {
   // Perform search operation
});

6. Structuring Your ViewModels
Break down complex ViewModels into smaller, manageable components. Use composition to assemble these components into a larger ViewModel.

function AddressViewModel(data) {
   var self = this;
   self.street = ko.observable(data.street);
   self.city = ko.observable(data.city);
}
function PersonViewModel(data) {
   var self = this;
   self.id = ko.observable(data.id);
   self.name = ko.observable(data.name);
   self.address = new AddressViewModel(data.address);
}
var personData = {
   id: 1,
   name: "John",
   address: {
       street: "123 Main St",
       city: "Somewhere"
   }
};
var viewModel = new PersonViewModel(personData);
ko.applyBindings(viewModel);

7. Using ko.pureComputed for Performance
ko.pureComputed helps create computed observables that are pure functions and do not depend on external state, leading to better performance.

var firstName = ko.observable('John');
var lastName = ko.observable('Doe');
var fullName = ko.pureComputed(function() {
   return firstName() + ' ' + lastName();
});

8. Managing Async Operations
Handle asynchronous operations (e.g., AJAX requests) efficiently by using promises and observables together.

function ViewModel() {
   var self = this;
   self.data = ko.observableArray([]);
   self.loadData = function() {
       $.ajax({
           url: 'data.json',
           type: 'GET',
           success: function(response) {
               self.data(response);
           }
       });
   };
   // Load data on initialization
   self.loadData();
}
ko.applyBindings(new ViewModel());

9. Optimizing DOM Updates with foreach Binding
Use foreach with as and $index to minimize DOM updates when working with lists.

<ul data-bind="foreach: { data: items, as: 'item' }">
   <li data-bind="text: item, attr: { 'data-index': $index }"></li>
</ul>

10. Using Web Workers for Heavy Computations
For heavy computations, offload processing to Web Workers to keep the UI responsive.

var worker = new Worker('worker.js');
worker.onmessage = function(e) {
   // Update observable with worker's result
   viewModel.result(e.data);
};
worker.postMessage(computationData);

Read more 

Angular JS custom Services Example.

What is an AngularJS module?

Advanced-Data Binding Techniques in Knockout.js

Custom validation rules and validation messages in knockout

Getting Started with Templates in Knockout.js